Click any tag below to further narrow down your results
+ ai
(6)
+ agent security
(1)
+ developer productivity
(1)
+ design taste
(1)
+ claude code
(1)
+ emilkowalskiskill
(1)
+ productivity
(1)
+ lennys podcast
(1)
+ agentic engineering
(1)
+ generalists
(1)
+ product thinking
(1)
+ code review
(1)
+ reasoning models
(1)
+ llm code generation
(1)
+ collaboration
(1)
Links
A developer walks through how their daily coding work changed across ChatGPT, Cursor tab completion, Claude agents, and Opus 4.5 through 5.5, ending with a model building a working notes app for iPhone from a single prompt. It reads as a personal timeline of AI tools moving from a better search box to something that handles most of the implementation.
- Productivity rose from a modest gain to roughly 3x (measured over a few months of merged PRs) once the Opus 4.5/6 models needed far less step-by-step prompting.
- The developer's role shifted from writing and reviewing every line to focusing on architecture, business logic, customer data, and irreversible changes, scanning the rest.
- A single prompt produced a basic working iPhone app that imported all their Electron notes, using about 40% of a $20 subscription's 5-hour limit.
Human software engineers paired with AI coding agents are currently more effective than either working alone, and this partnership phase could persist for 10-20 years before AI achieves full autonomy — giving engineers time to adapt rather than panic. The author argues we should treat software's trajectory like chess, which had a 20-year centaur age before AI dominance, though the outcome remains genuinely uncertain.
- Current AI coding agents (like Claude and Cursor) are reliable enough to work unsupervised but still need human review for alignment issues — matching technical values, avoiding over/under-engineering — making human-AI teams superior to either alone.
- Chess provides the closest historical parallel: its centaur age lasted about 20 years, while previous centaur ages (like humans with knitting frames) lasted 200+ years, suggesting software's could reasonably span a decade or two.
- The main risk isn't staying in software engineering for another decade — it's refusing to become a centaur by rejecting AI tools, or trying to jump ship early and give up a full career based on worst-case scenarios that may not materialize.
Simon Willison argues that pay-by-usage services should enforce hard budget caps by default—stopping service when spending hits a limit rather than just sending warnings—because coding agents make it too easy to accidentally rack up massive bills. AWS and Google Cloud recently launched these features, but they need to become standard across the industry.
- Soft budget caps (warning emails) fail in practice because automated agents and unattended services can incur thousands in charges overnight before anyone notices the alert.
- AWS and Google Cloud both launched hard spending limits recently (September and July 2026), pausing projects when monthly budgets are exceeded, but adoption and availability remain limited.
- The feature should be mandatory by default with an explicit opt-in checkbox to remove caps, shifting the burden of risk from users who fear bankruptcy to those willing to accept it.
- Many developers avoid AWS for personal projects specifically because of runaway cost fears, so hard caps would unlock adoption from risk-averse users.
Jake Goldsborough argues that AI coding agents aren't killing software engineering—they're freeing engineers from tedious mechanical work so they can focus on the actual problem-solving that defines the craft. The hard parts that never mattered (regex wrestling, syntax memorization, build system incantations) are disappearing, but the work that requires real judgment and responsibility remains.
- The difficult parts of coding—parsing edge cases, remembering obscure syntax, navigating unfamiliar codebases—were never the point; they were tolls between understanding a problem and solving it, and removing them doesn't diminish engineering skill.
- Agents handle syntax and scaffolding faster, which lets engineers explore domains that were previously too expensive (rewriting programs in different languages, understanding unfamiliar systems, testing experimental ideas), actually tightening the learning loop rather than replacing it.
- The real shift is architectural: engineering moves from "produce every character by hand" to "direction, judgment, verification, and responsibility," and the actual risk isn't that the work disappears but that companies cut people, generated code creates failures at scale, and the junior-to-senior training path collapses.
AI coding agents are already excellent at writing technically correct code, but they consistently produce solutions misaligned with organizational values and technical strategy. The real job of human programmers isn't improving code quality—it's steering AI toward what actually matters to their company.
- AI agents write code that compiles, avoids race conditions, and runs correctly, but often makes poor architectural choices and contradicts long-term strategy because they optimize for the wrong signals (like excessive comments and unit tests).
- Alignment is fundamentally harder to solve than raw capability and remains poorly understood, which is good news for engineers since it's unclear when—or if—AI will learn to match human organizational values without supervision.
- Unlike chess centaurs where humans and machines combined exceeded both separately, human-AI coding partnerships work because humans provide alignment, not capability—the AI is already better at the technical execution.
GLM-5.2, released quietly by Z.ai in mid-June, outperforms previous open models and even matches closed-lab giants on key benchmarks. Its strong community reception and coding-agent readiness signal a shift in the open-weight landscape, raising questions about pricing pressure, regulatory risk, and the future balance between open and closed AI.
- - GLM-5.2 reportedly matches OpenAI and Anthropic's top models on leaderboards like Arena and Design Arena, including outranking "Claude Fable" on Design Arena.
- - Its release came roughly 204 days (~6.8 months) after Claude Opus 4.5, matching the claimed 6-9 month lag between closed US models and open Chinese counterparts.
- - Developers report near-seamless migration from Claude Code to GLM-5.2 via Fireworks' API, despite minor bugs like crashes on image inputs.
- - The release is framed as pricing and competitive pressure on Anthropic, especially with "Claude Fable" described as banned in some markets, while also reigniting debates about regulation of powerful open-weight models.
Orca lets you run multiple code-generation agents (Codex, ClaudeCode, Pi, etc.) side-by-side in isolated git worktrees and compare or merge their outputs. It combines split terminals, UI scraping, remote execution, commit workflows, and real-time mobile notifications to manage and steer agents without context switching.
- Orca runs multiple AI coding agents (Codex, ClaudeCode, OpenCode, Pi, etc.) in parallel using isolated git worktrees, so you can fan out one prompt to several agents and merge the best output.
- It bundles a full dev environment—WebGL terminal, embedded VS Code with autosave, and Chromium-based UI scraping to capture HTML/CSS/screenshots directly into prompts.
- Mobile apps (iOS/Android) let you get notified when agents finish or need input, then steer them, review PRs, and comment on diffs remotely.
- It's MIT-licensed and open source, installable via Homebrew, AUR, or prebuilt binaries, with every action scriptable via CLI commands.
AgentsView is a self-hosted tool that indexes your AI coding agent sessions into a local SQLite or PostgreSQL store and serves a web UI on localhost. It tracks token usage and compute costs across multiple agents, offers CLI commands for usage reports, and supports Docker, desktop apps, and background server modes. It also provides full-text search, analytics dashboards, and per-session or daily cost breakdowns.
- AgentsView is a self-hosted, local-first tool that indexes AI coding agent sessions (Claude, Codex, Forge, OpenCode, and 20+ others) into SQLite/DuckDB/PostgreSQL with no cloud dependency.
- The CLI's `agentsview usage` command is positioned as a replacement for ccusage, giving sub-second token/cost breakdowns by model, date, or agent.
- It supports flexible deployment (install script, Homebrew, Docker, background daemon) with production-ready configs like read-only mounts, PostgreSQL backing, and optional public exposure via `--public-url`/`--require-auth`.
- Beyond raw usage stats, `agentsview stats` adds higher-level analytics like session archetypes (quick/deep/marathon) and optional Git-linked outcomes (commits, PRs).
This article argues that to get useful work from AI coding agents, teams must build a structured environment—context, tools, permissions, tests, and review loops—that guides stateless models and enforces deterministic feedback. It covers seven principles, from minimal and tested context to sandboxed credentials and self-validating work, so agents can onboard per task, prove their output, and operate safely at scale.
- Agents are stateless and need minimal, tested context (small rules/skills pointing to code) instead of a sprawling AGENTS.md
- Environments must be fully deterministic—locked dependencies, scripts, seed data, auth—so agents either work or fail clearly, no "I think this works" commits
- Agents should self-validate via tools like Playwright, Chrome DevTools MCP, and screenshot/accessibility checks, since burning extra tokens on closed-loop checks is cheaper than wasting human reviewer time
- Safety and access control need to be system design, not prompt hygiene—sandboxed credentials, scoped file/network access, approval gates, and audit trails so nontechnical users can't accidentally cause damage
This article covers the `npx skills` CLI tool for installing, listing, updating, and removing reusable agent “skills” across over 40 coding agents. You can fetch skills from GitHub, GitLab, local paths, or any Git URL and target specific agents or install globally versus per-project.
- `npx skills` lets you install reusable "agent skills" from any GitHub/GitLab repo, local path, or Git URL into 40+ coding agents (Claude Code, Cursor, Codex, OpenCode, etc.)
- Supports fine-grained control: pick specific skills or whole repos, target specific agents, install globally vs per-project, and run non-interactively via --yes/--all for CI/CD
- Full lifecycle management is built in: list, find, update, remove, and init (to scaffold a new SKILL.md) for authoring your own skills
- Defaults to symlinking skills (single source of truth) but can copy files instead if symlinks aren't supported; community skills are browsable at skills.sh
The author explains how to turn design decisions—like initial scale, easing, and typography rules—into explicit “skill files” that coding agents can follow. By articulating why certain animations feel natural, you guide AI agents to produce consistent, high-quality results. He demonstrates using Anthropic’s skill-creator and Claude Code, and shares a public skill package.
- Coding agents produce mediocre visual/animation work because they lack a trained eye, but this can be fixed by encoding design taste into explicit "skill files" with concrete rules instead of vague preferences
- Concrete example: starting animations at scale(0.85) instead of scale(0) creates natural-feeling growth versus jarring pop-in—showing how gut-feel taste can become codified logic (same applies to easing curves via decision trees)
- Using Anthropic's skill-creator, Claude Code can review existing animations against these rules and output specific violations plus before-and-after code fixes
- All these rules are packaged into an installable skill via `npx skills add emilkowalski/skill`
The article summarizes highlights from a podcast episode discussing recent advancements in AI and their impact on software engineering, particularly the emergence of coding agents. It covers topics like the inflection point in model capabilities, the changing role of software engineers, and the challenges faced by mid-career professionals.
- GPT 5.1 and Claude Opus 4.5 (released in November) marked a real inflection point where generated code became reliably functional rather than needing constant oversight
- The bottleneck in software development has shifted from writing code to testing it, since prototyping is now fast and cheap
- Running multiple coding agents simultaneously is mentally exhausting and risks burnout if overused
- Interruptions are now less costly to productivity since these tools let programmers pick back up quickly after breaks
This article discusses the impact of coding agents on the roles within Engineering, Product, and Design (EPD) teams. With coding becoming easier, the focus has shifted from creating detailed product requirement documents to rapid prototyping and review, emphasizing the need for generalists and strong system thinking. It highlights the evolving nature of roles where builders and reviewers emerge as distinct categories.
- Coding agents shift the bottleneck from writing code to reviewing it—checking architecture, user fit, and design quality.
- Generalists who span product, design, and engineering become more valuable because they cut coordination delays and can use coding agents directly to validate ideas.
- Weak product thinking now carries a higher cost: bad prototypes flood the review pipeline and waste team effort.
- System thinking becomes a core skill requirement—engineers need architecture/API fluency, PMs need real user insight, designers need interface judgment—so agents can be guided well instead of producing more review work.
In a podcast discussion, predictions for the tech industry in 2026 are shared, highlighting the undeniable improvement of LLMs in writing code, advancements in coding agent security, and the potential obsolescence of manual coding. Other predictions include a successful breeding season for Kākāpō parrots and the implications of AI-assisted programming on software engineering careers.
- LLMs will keep getting undeniably better at writing code through 2026, shifting more programming work to coding agents
- Security around coding agents will become a major focus as they gain more autonomy and access to systems
- Manual hand-coding may start becoming obsolete for significant portions of software engineering work, reshaping the profession
- Kākāpō parrots are predicted to have a successful breeding season in 2026
Exploring the effectiveness of coding agents hinges on effective user input, constraints, and context. By applying Steven Johnson's patterns for generating ideas, the article demonstrates how to enhance coding agent outputs through structured prompting and feedback mechanisms. This approach encourages incremental development, reuses existing solutions, and fosters a collaborative environment between humans and AI.
- Coding agents produce better output when users apply Steven Johnson's "good ideas" patterns (adjacent possible, liquid networks, slow hunches) as prompting strategies rather than treating the agent as a one-shot answer machine.
- Structured constraints and iterative feedback loops—not just clearer instructions—are what actually improve agent performance, mirroring how innovation historically emerges from recombination rather than isolated genius.
- Treating coding agents as collaborators to think alongside, rather than tools to extract finished answers from, leads to more incremental, reusable, and higher-quality code.
The article reviews significant trends and developments in the LLM space throughout 2025, highlighting breakthroughs in reasoning, the rise of coding agents, and the increasing use of LLMs in command-line interfaces. It notes the evolution of tools and models, including the impact of asynchronous coding agents and the normalization of YOLO mode for improved efficiency.
- Reasoning models became mainstream in 2025, significantly boosting LLM performance on complex tasks
- Coding agents surged in popularity, with asynchronous agents enabling developers to offload larger chunks of work
- "YOLO mode" (letting agents run commands without manual approval) went from risky novelty to normalized practice for efficiency
- LLMs increasingly moved into command-line interfaces, embedding AI more directly into developer workflows